/*
 * SessionBean1.java
 *
 * Created on 3/03/2014, 11:11:56 AM
 * Copyright RVGRFD85
 */
package scc;

import com.sun.rave.web.ui.appbase.AbstractSessionBean;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.List;
import javax.faces.FacesException;
import pojos.Areas;
import pojos.Asuntos;
import pojos.Direccion;
import pojos.Estados;
import pojos.OficiosExt;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import pojos.Dependencias;
import pojos.Usuarios;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import pojos.Enviados;
import pojos.Estatus;
import pojos.Oficinas;

/**
 * <p>Session scope data bean for your application.  Create properties
 *  here to represent cached data that should be made available across
 *  multiple HTTP requests for an individual user.</p>
 *
 * <p>An instance of this class will be created for you automatically,
 * the first time your application evaluates a value binding expression
 * or method binding expression that references a managed bean using
 * this class.</p>
 */
public class SessionBean1 extends AbstractSessionBean {
    // <editor-fold defaultstate="collapsed" desc="Managed Component Definition">
    private int __placeholder;

    /**
     * <p>Automatically managed component initialization.  <strong>WARNING:</strong>
     * This method is automatically generated, so any user-specified code inserted
     * here is subject to being replaced.</p>
     */
    private void _init() throws Exception {
    }
    // </editor-fold>

    /**
     * <p>Construct a new session data bean instance.</p>
     */
    public SessionBean1() {
    }

    /**
     * <p>This method is called when this bean is initially added to
     * session scope.  Typically, this occurs as a result of evaluating
     * a value binding or method binding expression, which utilizes the
     * managed bean facility to instantiate this bean and store it into
     * session scope.</p>
     * 
     * <p>You may customize this method to initialize and cache data values
     * or resources that are required for the lifetime of a particular
     * user session.</p>
     */
    public void init() {
        // Perform initializations inherited from our superclass
        super.init();
        // Perform application initialization that must complete
        // *before* managed components are initialized
        // TODO - add your own initialiation code here
        
        // <editor-fold defaultstate="collapsed" desc="Managed Component Initialization">
        // Initialize automatically managed components
        // *Note* - this logic should NOT be modified
        try {
            _init();
        } catch (Exception e) {
            log("SessionBean1 Initialization Failure", e);
            throw e instanceof FacesException ? (FacesException) e: new FacesException(e);
        }
        
        // </editor-fold>
        // Perform application initialization that must complete
        // *after* managed components are initialized
        // TODO - add your own initialization code here
    }

    /**
     * <p>This method is called when the session containing it is about to be
     * passivated.  Typically, this occurs in a distributed servlet container
     * when the session is about to be transferred to a different
     * container instance, after which the <code>activate()</code> method
     * will be called to indicate that the transfer is complete.</p>
     * 
     * <p>You may customize this method to release references to session data
     * or resources that can not be serialized with the session itself.</p>
     */
    public void passivate() {
    }

    /**
     * <p>This method is called when the session containing it was
     * reactivated.</p>
     * 
     * <p>You may customize this method to reacquire references to session
     * data or resources that could not be serialized with the
     * session itself.</p>
     */
    public void activate() {
    }

    /**
     * <p>This method is called when this bean is removed from
     * session scope.  Typically, this occurs as a result of
     * the session timing out or being terminated by the application.</p>
     * 
     * <p>You may customize this method to clean up resources allocated
     * during the execution of the <code>init()</code> method, or
     * at any later time during the lifetime of the application.</p>
     */
    public void destroy() {
    }
    public Session sesion=null;
    private boolean enLinea=false;
    private Usuarios usuarioGlobal;
    public Usuarios getUsuarioGlobal() {
        return usuarioGlobal;
    }
    public void setUsuarioGlobal(Usuarios usuarioGlobal) {
        this.usuarioGlobal = usuarioGlobal;
    }
    public Session getSesion() {
        return sesion;
    }
    public void setSesion(Session sesion) {
        this.sesion = sesion;
    }
    public boolean isEnLinea() {
        return enLinea;
    }
    public void setEnLinea(boolean enLinea) {
        this.enLinea = enLinea;
    }
    public void crearSesion(){
        if(sesion==null || !sesion.isOpen()){
            try{
                sesion=HibernateUtil.getSessionFactory().openSession();
            }catch(HibernateException ex){
                //this.mostrarMensaje(1);
            }
        }
    }
    /*METODO QUE FINALIZA LA SESION DE TRABAJO*/
    public void cerrarSesion(){
        this.setUsuarioGlobal(null);
        try{
            if(sesion!=null && sesion.isOpen()){
                sesion.flush();
                sesion.close();
                //sesion.disconnect();
            }
        }catch(HibernateException ex){
            sesion=null;
        //    this.mostrarMensaje("","");
        }
        this.setEnLinea(false);
    }
    public List<Asuntos> getCatalogoDeAsuntos() {
        List <Asuntos> catalogo=new ArrayList<Asuntos>();
        this.crearSesion();
        Transaction transaccion=null;
        String sentenciaSql="FROM Asuntos a where a.status=1 ORDER BY a.asuntos";
        try{
            transaccion=sesion.beginTransaction();
            Query consulta=sesion.createQuery(sentenciaSql);
            catalogo=consulta.list();
            transaccion.commit();
        }catch(Exception ex){
            transaccion.rollback();
        }finally{
            return catalogo;
        }
    }
    public   List<Estados> getCatalogoDeEstados() {
        List <Estados> catalogo=new ArrayList<Estados>();
        this.crearSesion();
        Transaction transaccion=null;
        String sentenciaSql="FROM Estados e where e.status=1 ORDER BY e.estado";
        try{
            transaccion=sesion.beginTransaction();
            Query consulta=sesion.createQuery(sentenciaSql);
            catalogo=consulta.list();
            transaccion.commit();
        }catch(Exception ex){
            transaccion.rollback();
        }finally{
            return catalogo;
        }
    }
    public List<Dependencias> getCatalogoDeDependencias(int estado) {
        List <Dependencias> catalogo=new ArrayList<Dependencias>();
        this.crearSesion();
        Transaction transaccion=null;
        String sentenciaSql="from Dependencias d where d.estados.idEstado="+estado+" and  d.status=1 ORDER BY d.dependencia";
        try{
            transaccion=sesion.beginTransaction();
            Query consulta=sesion.createQuery(sentenciaSql);
            catalogo=consulta.list();
            transaccion.commit();
        }catch(Exception ex){
            transaccion.rollback();
        }finally{
            return catalogo;
        }
    }
    List<Areas> getCatalogoDeAreas() {
        List <Areas> catalogo=new ArrayList<Areas>();
        this.crearSesion();
        Transaction transaccion=null;
        String sentenciaSql="from Areas d where d.status=1 ORDER  BY d.nombreArea";
        try{
            transaccion=sesion.beginTransaction();
            Query consulta=sesion.createQuery(sentenciaSql);
            catalogo=consulta.list();
            transaccion.commit();
        }catch(Exception ex){
            transaccion.rollback();
        }finally{
            return catalogo;
        }
    }

    List<Direccion> getCatalogoDeDirecciones(int area) {
        List <Direccion> catalogo=new ArrayList<Direccion>();
        this.crearSesion();
        Transaction transaccion=null;
        String sentenciaSql="from Direccion d where d.areas.idArea="+area+" and  d.status=1 ORDER BY d.nombreDirec";
        try{
            transaccion=sesion.beginTransaction();
            Query consulta=sesion.createQuery(sentenciaSql);
            catalogo=consulta.list();
            transaccion.commit();
        }catch(Exception ex){
            transaccion.rollback();
        }finally{
            return catalogo;
        }
    }

    List<Oficinas> getCatalogoDeOficinas(int direccion) {
        List <Oficinas> catalogo=new ArrayList<Oficinas>();
        this.crearSesion();
        Transaction transaccion=null;
        String sentenciaSql="from Oficinas d where d.direccion.idDireccion="+direccion+" and d.status=1 ORDER BY d.oficina";
        try{
            transaccion=sesion.beginTransaction();
            Query consulta=sesion.createQuery(sentenciaSql);
            catalogo=consulta.list();
            transaccion.commit();
        }catch(Exception ex){
            transaccion.rollback();
        }finally{
            return catalogo;
        }
    }
    List<Oficinas> getCatalogoDeOficinasMenosMia(int direccion) {
        List <Oficinas> catalogo=new ArrayList<Oficinas>();
        this.crearSesion();
        Transaction transaccion=null;
        String sentenciaSql="from Oficinas d where d.direccion.idDireccion="+direccion+" and d.status=1 and d.idOficina != " + this.getOficinaGlobal().getIdOficina() + " ORDER BY d.oficina";
        try{
            transaccion=sesion.beginTransaction();
            Query consulta=sesion.createQuery(sentenciaSql);
            catalogo=consulta.list();
            transaccion.commit();
        }catch(Exception ex){
            transaccion.rollback();
        }finally{
            return catalogo;
        }
    }

    List<OficiosExt> llenaOficiosEntrada(int oficina) {
        List <OficiosExt> catalogo=new ArrayList<OficiosExt>();
        this.crearSesion();
        Transaction transaccion=null;
        try{
            catalogo.clear();
            transaccion=sesion.beginTransaction();
            Query consulta=sesion.createQuery("from OficiosExt o where o.oficinas.idOficina= "+ oficina+ " and ( tipo='entrada-e' or tipo='salida-i' or tipo='salida-ne' ) order by o.prioridad asc, o.idOficio desc");
            catalogo=consulta.list();
            sesion.flush();
        }catch(HibernateException ex){
            transaccion.rollback();
        }finally{//
            return catalogo;
        }
    }
    List<OficiosExt> llenaOficiosSalida(int usuario) {
        List <OficiosExt> catalogo=new ArrayList<OficiosExt>();
        this.crearSesion();
        Transaction transaccion=null;
        try{
            catalogo.clear();
            transaccion=sesion.beginTransaction();
            Query consulta=sesion.createQuery("from OficiosExt o where o.usuarios.idUsuario= "+ usuario+ " and ( tipo='salida-i' or tipo='salida-e') order by o.prioridad asc, fecha_prioridad asc");
            catalogo=consulta.list();
            sesion.flush();
        }catch(HibernateException ex){
            transaccion.rollback();
        }finally{//
            return catalogo;
        }
    }
    private Oficinas oficinaGlobal= new Oficinas();
    public Oficinas getOficinaGlobal() {
        return oficinaGlobal;
    }
    public void setOficinaGlobal(Oficinas oficinaGlobal) {
        this.oficinaGlobal = oficinaGlobal;
    }
    private String labelGlobalDataUser;
    public String getLabelGlobalDataUser() {
        return labelGlobalDataUser;
    }
    public void setLabelGlobalDataUser(String labelGlobalDataUser) {
        this.labelGlobalDataUser = labelGlobalDataUser;
    }

    Usuarios login(String alias, String contrasena) {
        this.crearSesion();
        Transaction transaccion=null;
        this.setUsuarioGlobal(null);
        try{
            transaccion=sesion.beginTransaction();
            //String passCrypted=this.getHash(contrasena);
            Query consulta=sesion.createQuery("FROM Usuarios where usuario=? AND contrasena=? and status=1");
            consulta.setString(0, alias);
            consulta.setString(1, contrasena);
            if(consulta.list().size()>0){
                this.setUsuarioGlobal( (Usuarios) consulta.uniqueResult());
                this.setOficinaGlobal(this.getUsuarioGlobal().getOficinas());
                this.setLabelGlobalDataUser("Usuario: "+usuarioGlobal.getNombre()+ " "+ usuarioGlobal.getPaterno()+" ---- " + " " + oficinaGlobal.getOficina());
            }else{
                this.cerrarSesion();
            }
            transaccion.commit();
            transaccion.commit();
            sesion.flush();
            sesion.close();
            //sesion.disconnect();
        }catch(HibernateException ex){
            transaccion.rollback();
            this.cerrarSesion();
            //this.mostrarMensaje("","");
        }finally{
            return this.usuarioGlobal;
        }
    }
    private Enviados nuevoEnviado=new Enviados();
    public Enviados getNuevoEnviado() {
        return nuevoEnviado;
    }
    public void setNuevoEnviado(Enviados nuevoEnviado) {
        this.nuevoEnviado = nuevoEnviado;
    }
    void addOficioExterno(OficiosExt oficioExterno) {
        this.crearSesion();
        try{
            this.sesion.clear();
            Transaction transaccion=this.sesion.beginTransaction();
            //        un dia mas a la fecha de resolucion Elemento icefaces
            Date uno=oficioExterno.getFechaRecepcion();
            Calendar cal = new GregorianCalendar();
            cal.setTimeInMillis(uno.getTime());
            cal.add(Calendar.DATE, +1);
            oficioExterno.setFechaRecepcion(cal.getTime());
            //
            //        un dia mas a la fecha de resolucion Elemento icefaces
            if(oficioExterno.getFecha_prioridad()!=null){
                Date dos=oficioExterno.getFecha_prioridad();
                Calendar cal1 = new GregorianCalendar();
                cal1.setTimeInMillis(dos.getTime());
                cal1.add(Calendar.DATE, +1);
                oficioExterno.setFecha_prioridad(cal1.getTime());
            }
            //
            this.sesion.saveOrUpdate(oficioExterno);
            transaccion.commit();
            ///addEnviados(oficioExterno);
        }catch(HibernateException e){
           //this.mostrarMensaje("Error", e.getCause().toString());
        }finally {
          this.sesion.clear();
        }
    }
    void addOficioExternoSalida(OficiosExt oficioExterno) {
        this.crearSesion();
        try{
            this.sesion.clear();
            Transaction transaccion=this.sesion.beginTransaction();
            //        un dia mas a la fecha de resolucion Elemento icefaces
            if(oficioExterno.getFechaRecepcion()!=null){
                Date uno=new Date();
                Calendar cal = new GregorianCalendar();
                cal.setTimeInMillis(uno.getTime());
                cal.add(Calendar.DATE, +1);
                oficioExterno.setFechaRecepcion(cal.getTime());
            }else{
                DateFormat df1;
                df1 = DateFormat.getDateInstance(DateFormat.MEDIUM);
                Date now = new Date();
                oficioExterno.setFechaRecepcion(now);
            }
            //        un dia mas a la fecha de resolucion Elemento icefaces
            if(oficioExterno.getFecha_prioridad()!=null){
                Date dos=oficioExterno.getFecha_prioridad();
                Calendar cal1 = new GregorianCalendar();
                cal1.setTimeInMillis(dos.getTime());
                cal1.add(Calendar.DATE, +1);
                oficioExterno.setFecha_prioridad(cal1.getTime());
            }
            //
            this.sesion.saveOrUpdate(oficioExterno);
            transaccion.commit();
            ///addEnviados(oficioExterno);
        }catch(HibernateException e){
           //this.mostrarMensaje("Error", e.getCause().toString());
        }finally {
          this.sesion.clear();
        }
    }
    void addOficioInternoSalida(OficiosExt oficioExterno) {
        this.crearSesion();
        try{
            this.sesion.clear();
            Transaction transaccion=this.sesion.beginTransaction();
            //        un dia mas a la fecha de resolucion Elemento icefaces
            if(oficioExterno.getFechaRecepcion()!=null){
                Date uno=new Date();
                Calendar cal = new GregorianCalendar();
                cal.setTimeInMillis(uno.getTime());
                cal.add(Calendar.DATE, +1);
                oficioExterno.setFechaRecepcion(cal.getTime());
            }else{
                DateFormat df1;
                df1 = DateFormat.getDateInstance(DateFormat.MEDIUM);
                Date now = new Date();
                oficioExterno.setFechaRecepcion(now);
            }
            //        un dia mas a la fecha de resolucion Elemento icefaces
            if(oficioExterno.getFecha_prioridad()!=null){
                Date dos=oficioExterno.getFecha_prioridad();
                Calendar cal1 = new GregorianCalendar();
                cal1.setTimeInMillis(dos.getTime());
                cal1.add(Calendar.DATE, +1);
                oficioExterno.setFecha_prioridad(cal1.getTime());
            }
            //
            this.sesion.saveOrUpdate(oficioExterno);
            transaccion.commit();
            ///addEnviados(oficioExterno);
        }catch(HibernateException e){
           //this.mostrarMensaje("Error", e.getCause().toString());
        }finally {
          this.sesion.clear();
        }
    }
    void addOficioInternoSalidaAqui(OficiosExt oficioExterno, Oficinas unaOficina) {
        this.crearSesion();
        this.sesion.clear();
         try{
            Transaction t=this.sesion.beginTransaction();
            t=sesion.beginTransaction();
            Query consulta=sesion.createQuery("FROM Usuarios u where u.oficinas.idOficina=? ");
            consulta.setInteger(0, unaOficina.getIdOficina());
            Usuarios u= (Usuarios) consulta.uniqueResult();

            this.sesion.clear();
            Usuarios us= new Usuarios();
            this.sesion.load(us, new Integer(u.getIdUsuario()));
            oficioExterno.setUsuarios(us);
            sesion.flush();
            sesion.close();
            //sesion.disconnect();
        }catch(HibernateException ex){
            this.mostrarMensajeAlert("Error",ex.getCause().toString());
        }
        try{
            this.crearSesion();
            this.sesion.clear();
            //Calendar c = Calendar.getInstance();
            //String annio = Integer.toString(c.get(Calendar.YEAR));
            //Oficinas of= new Oficinas();
            //this.sesion.load(of, new Integer(unaOficina.getIdOficina()));
            //oficioExterno.setNoOficio(oficioExterno.getNoOficio()+"/"+of.getSiglas()+"/"+annio);

            this.sesion.clear();
            Transaction transaccion=this.sesion.beginTransaction();
            //        un dia mas a la fecha de resolucion Elemento icefaces
            if(oficioExterno.getFechaRecepcion()!=null){
                Date uno=new Date();
                Calendar cal = new GregorianCalendar();
                cal.setTimeInMillis(uno.getTime());
                cal.add(Calendar.DATE, +1);
                oficioExterno.setFechaRecepcion(cal.getTime());
            }else{
                DateFormat df1;
                df1 = DateFormat.getDateInstance(DateFormat.MEDIUM);
                Date now = new Date();
                oficioExterno.setFechaRecepcion(now);
            }
            //        un dia mas a la fecha de resolucion Elemento icefaces
            if(oficioExterno.getFecha_prioridad()!=null){
                Date dos=oficioExterno.getFecha_prioridad();
                Calendar cal1 = new GregorianCalendar();
                cal1.setTimeInMillis(dos.getTime());
                cal1.add(Calendar.DATE, +1);
                oficioExterno.setFecha_prioridad(cal1.getTime());
            }
            //
            this.sesion.saveOrUpdate(oficioExterno);
            transaccion.commit();
        }catch(HibernateException e){
           this.mostrarMensajeAlert("Error", e.getCause().toString());
        }finally {
          this.sesion.clear();
        }
    }

    void addEnviados(OficiosExt oficioExterno){
        this.nuevoEnviado.setIdEnviado(0);
        this.nuevoEnviado.setOficiosExt(oficioExterno);
        DateFormat df1;
        df1 = DateFormat.getDateInstance(DateFormat.MEDIUM);
        Date now = new Date();
        this.nuevoEnviado.setFechaEnvio(now);
        try{
            this.sesion.clear();
            Oficinas of= new Oficinas();
            this.sesion.load(of, new Integer(1));
            this.nuevoEnviado.setOficinas(of);

            Usuarios us= new Usuarios();
            this.sesion.load(us, new Integer(1));
            this.nuevoEnviado.setUsuarios(us);

            Estatus es= new Estatus();
            this.sesion.load(es, new Integer(1));
            this.nuevoEnviado.setEstatus(es);

            Asuntos as= new Asuntos();
            this.sesion.load(as, new Integer(1));
            this.nuevoEnviado.setAsuntos(as);
        }catch (Exception e){
            //this.mostrarMensaje("", e.toString());
        }
        this.nuevoEnviado.setStatus(true);
        this.nuevoEnviado.setDescripcion("");
        this.nuevoEnviado.setFecha_prioridad(now);
        this.nuevoEnviado.setNoOficio("");
        this.nuevoEnviado.setDependencia_externa(1);
        this.crearSesion();

        try{
            this.sesion.clear();
            Transaction transaccion=this.sesion.beginTransaction();
            this.sesion.saveOrUpdate(nuevoEnviado);
            transaccion.commit();

        }catch(HibernateException e){
           //this.mostrarMensaje("Error", e.getCause().toString());
        }finally {
          this.sesion.clear();
        }
    }


    private String tituloAlert;
    private String msgAlert;
    private boolean VentanaAlert;
    private boolean VentanaError;

    public boolean isVentanaAlert() {
        return VentanaAlert;
    }
    public void setVentanaAlert(boolean VentanaAlert) {
        this.VentanaAlert = VentanaAlert;
    }
    public boolean isVentanaError() {
        return VentanaError;
    }
    public void setVentanaError(boolean VentanaError) {
        this.VentanaError = VentanaError;
    }
    public String getMsgAlert() {
        return msgAlert;
    }
    public void setMsgAlert(String msgAlert) {
        this.msgAlert = msgAlert;
    }
    public String getTituloAlert() {
        return tituloAlert;
    }
    public void setTituloAlert(String tituloAlert) {
        this.tituloAlert = tituloAlert;
    }
    void mostrarMensajeAlert(String titulo, String msg) {
        this.setTituloAlert(titulo);
        this.setMsgAlert(msg);
        this.setVentanaAlert(true);
    }
    void mostrarMensajeError(String titulo, String msg) {
        this.setTituloAlert(titulo);
        this.setMsgAlert(msg);
        this.setVentanaError(true);
    }
}
